/* * Copyright © 2020-2024 spj * Released under the MIT License. */
'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var axios = _interopDefault(require('axios'));

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (enumerableOnly) symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    });
    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(source, true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(source).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

var script = {
  name: 'Upload',
  components: {},
  props: {
    uploadUrl: {
      type: String,
      required: true,
      default: undefined
    },
    name: {
      type: String,
      default: '选择文件'
    },
    value: {
      type: [String, Array],
      default: ''
    },
    header: {
      type: Object,
      default: function _default() {}
    },
    multiple: {
      type: Boolean,
      default: false
    },
    data: {
      type: Object,
      default: function _default() {}
    },
    beforeUpload: {
      type: Function,
      default: undefined
    }
  },
  data: function data() {
    return {};
  },
  created: function created() {},
  mounted: function mounted() {},
  methods: {
    onSelectFileEvent: function onSelectFileEvent() {
      this.$refs.fileSelector.click();
    },
    onFileChangeEvent: function onFileChangeEvent(files) {
      var selectFiles = this.$refs.fileSelector.files;

      if (this.beforeUpload && typeof this.beforeUpload === 'function' && !this.beforeUpload(selectFiles)) {
        return;
      }

      this.uploadFileList(selectFiles);
    },
    uploadFileList: function uploadFileList(files) {
      var _this = this;

      var extData = _objectSpread2({}, this.data);

      var _loop = function _loop(i, len) {
        var formData = new FormData();
        formData.append('file', files[i]); // 通过append向form对象添加数据

        Object.keys(extData).forEach(function (key) {
          formData.append(key, extData[key]); // 添加form表单中其他数据
        });
        var fileInfo = {
          fileName: files[i].name,
          type: files[i].type,
          file: files[i]
        };
        var options = {
          url: _this.url,
          headers: _this.headers,
          timeout: 30000,
          // 请求超时时间
          onUploadProgress: function onUploadProgress(res) {
            var progress = Math.floor(res.loaded / res.total * 10) / 10;

            _this.$emit('onUploadProgress', _objectSpread2({}, fileInfo, {
              progress: progress
            }));
          }
        };
        axios.create(options).post(_this.uploadUrl, formData).then(function (res) {
          if (res.status === 200) {
            _this.$emit('change', _objectSpread2({
              response: res.data
            }, fileInfo));

            console.log('==上传成功==', res.data);
          } else {
            console.error('==上传失败==', res);

            _this.$emit('fail', _objectSpread2({}, fileInfo, {
              msgData: res
            }));
          }
        }).catch(function (reason) {
          _this.$emit('fail', _objectSpread2({}, fileInfo, {
            msgData: reason
          }));

          console.error('==上传失败==', reason);
        });
      };

      for (var i = 0, len = files.length; i < len; i++) {
        _loop(i);
      }
    }
  }
};

function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier
/* server only */
, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {
  if (typeof shadowMode !== 'boolean') {
    createInjectorSSR = createInjector;
    createInjector = shadowMode;
    shadowMode = false;
  } // Vue.extend constructor export interop.


  var options = typeof script === 'function' ? script.options : script; // render functions

  if (template && template.render) {
    options.render = template.render;
    options.staticRenderFns = template.staticRenderFns;
    options._compiled = true; // functional template

    if (isFunctionalTemplate) {
      options.functional = true;
    }
  } // scopedId


  if (scopeId) {
    options._scopeId = scopeId;
  }

  var hook;

  if (moduleIdentifier) {
    // server build
    hook = function hook(context) {
      // 2.3 injection
      context = context || // cached call
      this.$vnode && this.$vnode.ssrContext || // stateful
      this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext; // functional
      // 2.2 with runInNewContext: true

      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
        context = __VUE_SSR_CONTEXT__;
      } // inject component styles


      if (style) {
        style.call(this, createInjectorSSR(context));
      } // register component module identifier for async chunk inference


      if (context && context._registeredComponents) {
        context._registeredComponents.add(moduleIdentifier);
      }
    }; // used by ssr in case component is cached and beforeCreate
    // never gets called


    options._ssrRegister = hook;
  } else if (style) {
    hook = shadowMode ? function () {
      style.call(this, createInjectorShadow(this.$root.$options.shadowRoot));
    } : function (context) {
      style.call(this, createInjector(context));
    };
  }

  if (hook) {
    if (options.functional) {
      // register for functional component in vue file
      var originalRender = options.render;

      options.render = function renderWithStyleInjection(h, context) {
        hook.call(context);
        return originalRender(h, context);
      };
    } else {
      // inject component registration as beforeCreate hook
      var existing = options.beforeCreate;
      options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
    }
  }

  return script;
}

var normalizeComponent_1 = normalizeComponent;

/* script */ var __vue_script__ = script;
/* template */
var __vue_render__ = function() {
  var _vm = this;
  var _h = _vm.$createElement;
  var _c = _vm._self._c || _h;
  return _c(
    "div",
    {
      staticClass: "sv-upload-button",
      on: {
        click: function($event) {
          $event.stopPropagation();
          return _vm.onSelectFileEvent($event)
        }
      }
    },
    [
      _c("input", {
        ref: "fileSelector",
        staticClass: "sv-input-bt",
        staticStyle: { display: "none" },
        attrs: { multiple: _vm.multiple, name: _vm.name, type: "file" },
        on: { change: _vm.onFileChangeEvent }
      }),
      _vm._v(" "),
      _vm._t("default")
    ],
    2
  )
};
var __vue_staticRenderFns__ = [];
__vue_render__._withStripped = true;

  /* style */
  var __vue_inject_styles__ = undefined;
  /* scoped */
  var __vue_scope_id__ = undefined;
  /* module identifier */
  var __vue_module_identifier__ = undefined;
  /* functional template */
  var __vue_is_functional_template__ = false;
  /* style inject */
  
  /* style inject SSR */
  

  
  var Upload = normalizeComponent_1(
    { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },
    __vue_inject_styles__,
    __vue_script__,
    __vue_scope_id__,
    __vue_is_functional_template__,
    __vue_module_identifier__,
    undefined,
    undefined
  );

Upload.install = function (vue) {
  vue.component(Upload.name, Upload);
};

module.exports = Upload;
